/**
* 在rust中Option是一个及其常见和重要的枚举类型，它有两个成员:Some和None。
*
* 关于Option我们需要掌握这样一些知识：
* 1、Option是什么，如何定义？有什么成员
* 2、Option的用处是什么？或者说为什么会有Option的存在
*    a、Option的存在是为了处理可能不存在的值
*    b、Option的存在是为了处理错误
*    c、Option的存在是为了处理空值
* 所有这些存在的主要目的是为符合rust的设计哲学：安全

* 3、如何获取Option中的值？或者说如何获取Some中的值？
*    a、使用方法获取
*    b、使用match表达式获取
*    c、使用？
*
* 4、方法汇总
*    a.查询,包括is_some, is_none
*    b.引用相关的方法，包括as_ref, as_mut，as_deref，as_deref_mut等
*    c.抽取值的方法，包括unwrap, unwrap_or, expect等
*    d.转换内含值的方法，包括map, map_or, ok_or等
*    e.布尔逻辑运算，包括and, or、and_then等
*    f、比较两个Option的值
*    g、迭代Option中的值
*    h、收集Option中的值
*    i、修改Option中的值
*
*    这些方法又可以简化为几个大类:
*    a.查询
*    b.抽取值
*    c.转换,包括常规转换、迭代、收集等
*    d.运算，包括布尔运算，比较等
*    e.修改
* 总结
*    学些Option，主要是为了处理可能不存在的值
*    所以，要熟记Option用处，方法的分类。
*/

use std::iter::Sum;
#[derive(Debug)]
struct Area {
    width: u32,
    height: u32,
    flag: bool,
}

impl Default for Area {
    fn default() -> Self {
        Area {
            width: 103,
            height: 2012,
            flag: true,
        }
    }
}
impl Iterator for Area {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.flag {
            let area = self.width * self.height;
            self.flag = false;
            Some(area)
        } else {
            None
        }
    }
}
/**
 * 实现这个以便直接比较两个Area对象的大小，因为Rust不允许直接对结构体进行比较
 */
impl PartialEq for Area {
    fn eq(&self, other: &Self) -> bool {
        let self_area = self.width * self.height;
        let other_area = other.width * other.height;
        self_area == other_area
    }
}
/**
 * 实现这个以便直接比较两个Area对象的大小，因为Rust不允许直接对结构体进行比较
 */
impl PartialOrd for Area {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        let self_area = self.width * self.height;
        let other_area = other.width * other.height;
        Some(self_area.cmp(&other_area))
    }
}
impl Area {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

#[derive(Debug)]
struct Exam{
    test_time:u32,
    score:u32,
}
impl Sum for Exam{
   fn sum<I>(iter: I) -> Self
       where I: Iterator<Item = Exam>{
        let mut total=Exam{test_time:0,score:0};
        for x in iter{
            if total.test_time==0 {
                total.test_time = x.test_time;
            }            
            total.score += x.score;
        }
        total
  }
}


fn main() {
    println!("\n-- 测试直接操作   \n");
    let _r = test_direct_add(Some(1), Some(2));
   

    //两个同种Option直接比较
    println!("\n-- 测试直接比较   \n");
    test_direct_compare();
    
    //
    println!("\n-- 测试抽取值相关的方法   \n");
    test_extract_value();

    println!("\n-- 测试修改相关的方法   \n");
    test_modify();

    println!("\n-- 测试操作相关的方法   \n");
    test_operate();

    println!("\n-- 测试查询   \n");
    let value = Some(String::from("健康饮食。66天养成一个习惯"));
    test_query(value);

    println!("\n-- 测试引用相关的方法   \n");
    test_ref();

    println!("\n-- 测试转换相关的方法   \n");
    test_transform();
   
}

/**
 * 两个Option可以直接比较，如果二者都实现了PartialOrd(Ord也可以)
 * 那么可以使用基本的比较运算符进行比较
 */
fn  test_direct_compare(){
    println!("要求其中的T实现PartialOrd");
    let d=Area::default();
    let a=Area{width: 10, height:20, flag:true};
    if d>a{
        println!("{:?}>{:?}",d,a);
    }else{
        println!("{:?}<={:?}",d,a);
    }
}

/**
 * 直接使用?操作符，如果Option是Some则返回里面的值，如果是None则返回None。
 */
fn test_direct_add(a: Option<i32>, b: Option<i32>) -> Option<i32> {
    let result=Some(a? + b?);
    println!("{}+{}={}",a.unwrap(),b.unwrap(), result.unwrap());
    result
}

/**
 * 取值后，通常而言，原来的变量不可在引用
 */
fn test_extract_value() {
    //测试unwrap_or 和unwrap_or_else
    //unwrap_or_else 要求参数是一个FnOnce类型的匿名函数，且返回T类型值。

    let book = None;
    let book_name = book.unwrap_or("沈氏四声考".to_string()); //unwrap_or获取默认值
    println!("None unwrap_or后,值={}", book_name);
    let book = Some("沈氏四声考".to_string());
    let book1=Some("沈氏四声考".to_string());
    let book_name = book.unwrap_or_else(|| "沈氏四声考?".to_string()); //unwrap_or获取默认值
    println!("{:?}中的值通过unwrap_or_else={}", book1,book_name);

    //测试unwrap_or_default,此方法要求T类型实现Default trait，所以如果没有值情况下，返回的是该类型的默认值。
    let area: Option<Area> = None;
    let area_default = area.unwrap_or_default(); //获取默认值
    println!("Area是一个None,默认={:?}", area_default.area());

    //测试take,take_if,replace等方法。
    // take --take(&mut self) -> Option<T>  ，原来的变为None
    // take_if take_if<P>(&mut self, predicate: P) -> Option<T>。p:FnOnce(&mut T) -> bool
    //         在取的时候，可以对数据进行修改
    // replace replace(&mut self, value: T) -> Option<T>，替换原来的值,返回来源的值。关键是原来的保留，新的也存在.

    let mut a=Some(10);
    let ta=a.take(); //取出值，并把原来的值设置为None。
    println!("{:?}被取出后={:?}",ta, a);
    //take_if 要求参数是一个FnOnce类型的匿名函数，且返回bool类型值。
    let mut b=Some(20);
    let tb=b.take_if(|x| *x>30);
    println!("{:?}被取出后={:?}",tb, b);
    //replace 要求参数是T类型值。
    let mut c=Some(30);
    let old=c.replace(40);
    println!("c={:?},old={:?}", c,old);

}

/**
 * 测试如何修改一个Option内含值
 */
fn test_modify(){
   //方式有多种，已知的略。
   println!("演示insert,get_or_insert方法。");
   //此处介绍insert,get_or_insert方法。
   //insert(&mut self, value: T) -> &mut T，会替换原来的值（如果有）
   //get_or_insert(&mut self, value: T) -> &mut T ， 如果没有值，则插入，否则取出已有的值。
   //不太明白这些方法有什么使用场景?

   let mut a=Some(10);
   let b=a.insert(20);
   *b+=10;
   println!("b={:?}", b);
   println!("a={:?}", a.unwrap());

   let mut a1=None;
   let c=a1.get_or_insert(30);
   println!("c={:?}", c);


}

fn test_operate(){
    //测试and - and只要有一个是None，则返回None,否则返回参数值
    //不知道这方法有何用？ 就是用于测试两个Option?
    //除了and,还有or和xor。
    //or取其中一个值，如果有一个值是Some,则取之。如果变量本身是Some，则返回本身
    //xor和or基本一样，不同的是如果x.xor(y)中x,y都是Some，则返回None。

    let a = Some(10);
    let b:Option<u32> = None;
    let c=a.and(b);
    println!("c={:?}", c);

    //测试and_with
    let fx=|_|{Some(100)};
    let c=a.and_then(fx);
    println!("c={:?}", c);

}

fn test_query(value: Option<String>) {
    if value.is_some() {
        println!("{}", value.unwrap());
    } else {
        println!("没有值");
    }
}

/**
 * rust可以象js那么随意，在函数中定义函数
 */
fn test_ref() {
    fn validate_type(val: Option<&String>) {
        match val {
            Some(v) => println!("{}", *v),
            None => println!("没有值"),
        }
    }
    let a = Some(String::from("今君往死地，沉痛迫中肠"));
    let ref_a = &a; // &Option<String>
    let ref_a_ref = ref_a.as_ref(); //Option<&String>
    validate_type(ref_a_ref);
}


fn test_transform() {
    let book: Option<i32> = None;
    let book_name = book.ok_or(-1);
    println!("{:?}", book_name);

    //测试无聊函数filter等。
    //filter函数要求T本身实现Iterator trait. struct转为迭代器本身就是很罕见的。
    let score = Some(10);
    let dd = score.filter(|x| *x >= 10); // filter要求FnOnce的参数是&T类型。
    println!("过滤后，{:?}", dd.unwrap());

    //测试map方法。
    //map返回Option<U>
    let area_default= Some(Area::default());
    println!("默认值={:?}", area_default);
    let area_new = area_default.map(|a| {
       a.area()
    });
    println!("area_new={:?}", area_new);

    //测试合并 x.zip(y)=Some((x,y))，如果其中一个为None则返回None。
    let rubbish=score.zip(area_new);
    println!("合并结果1={:?}", rubbish);
    let rubbish=book.zip(score);
    println!("合并结果2={:?}", rubbish);
    let rubbish=score.zip(book);
    println!("合并结果3={:?}", rubbish);

    //迭代行为,这是一种自动行为，不需要显式调用。
    let score:[u32;3]=[10,20,30];
    let score_vec:Vec<u32>=score.into_iter().chain(Some(90)).collect();
    println!("合并结果4(利用迭代器)={:?}", score_vec);
    //如果T实现了Sum，Product等trait，则可以调用sum,product等方法。 但是如果有一个成员为None，则返回None。
    let score1=Some(Exam{
        score:10,
        test_time:1994
    });
    let score2=Some(Exam{
        score:20,
        test_time:1994
    });
    let score_arr = [score1,score2];
    let sum:Option<Exam>=score_arr.into_iter().sum();
    println!("总成绩={:?}", sum);
    
    //收集
    //收集Option还是有一些价值的.
    //注意：只要其中过一个是None，则返回None。

    let v:[Option<u32>;4] = [Some(2), Some(4), None, Some(8)];
    let res: Option<Vec<u32>> = v.into_iter().collect();
    println!("通过collect收集的结果5(收集)={:?}", res.unwrap_or_default());
    //展示一个不是None的集合，返回的还是Option<Vec<T>>,所以需要unwrap一下。
    let v:[Option<u32>;4] = [Some(2), Some(4), Some(880), Some(8)];
    let res: Option<Vec<u32>> = v.into_iter().collect();
    println!("通过collect收集的结果5(收集)={:?}", res.unwrap());

}
